<!DOCTYPE html>
        <html>
        <head>
            <meta charset="UTF-8">
            <title>C&sol;C&plus;&plus;&#x671f;&#x672b;&#x8003;&#x8bd5;&#x6a21;&#x62df;&#x9898;&#x7b54;&#x6848;&#xff08;2024&#xff09;</title>
            <style>
/* From extension vscode.github */
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

.vscode-dark img[src$=\#gh-light-mode-only],
.vscode-light img[src$=\#gh-dark-mode-only],
.vscode-high-contrast:not(.vscode-high-contrast-light) img[src$=\#gh-light-mode-only],
.vscode-high-contrast-light img[src$=\#gh-dark-mode-only] {
	display: none;
}

</style>
            <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex/dist/katex.min.css">
<link href="https://cdn.jsdelivr.net/npm/katex-copytex@latest/dist/katex-copytex.min.css" rel="stylesheet" type="text/css">
        <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/Microsoft/vscode/extensions/markdown-language-features/media/markdown.css">
<link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/Microsoft/vscode/extensions/markdown-language-features/media/highlight.css">
<style>
            body {
                font-family: -apple-system, BlinkMacSystemFont, 'Segoe WPC', 'Segoe UI', system-ui, 'Ubuntu', 'Droid Sans', sans-serif;
                font-size: 14px;
                line-height: 1.6;
            }
        </style>
        <style>
.task-list-item {
    list-style-type: none;
}

.task-list-item-checkbox {
    margin-left: -20px;
    vertical-align: middle;
    pointer-events: none;
}
</style>
<style>
:root {
  --color-note: #0969da;
  --color-tip: #1a7f37;
  --color-warning: #9a6700;
  --color-severe: #bc4c00;
  --color-caution: #d1242f;
  --color-important: #8250df;
}

</style>
<style>
@media (prefers-color-scheme: dark) {
  :root {
    --color-note: #2f81f7;
    --color-tip: #3fb950;
    --color-warning: #d29922;
    --color-severe: #db6d28;
    --color-caution: #f85149;
    --color-important: #a371f7;
  }
}

</style>
<style>
.markdown-alert {
  padding: 0.5rem 1rem;
  margin-bottom: 16px;
  color: inherit;
  border-left: .25em solid #888;
}

.markdown-alert>:first-child {
  margin-top: 0
}

.markdown-alert>:last-child {
  margin-bottom: 0
}

.markdown-alert .markdown-alert-title {
  display: flex;
  font-weight: 500;
  align-items: center;
  line-height: 1
}

.markdown-alert .markdown-alert-title .octicon {
  margin-right: 0.5rem;
  display: inline-block;
  overflow: visible !important;
  vertical-align: text-bottom;
  fill: currentColor;
}

.markdown-alert.markdown-alert-note {
  border-left-color: var(--color-note);
}

.markdown-alert.markdown-alert-note .markdown-alert-title {
  color: var(--color-note);
}

.markdown-alert.markdown-alert-important {
  border-left-color: var(--color-important);
}

.markdown-alert.markdown-alert-important .markdown-alert-title {
  color: var(--color-important);
}

.markdown-alert.markdown-alert-warning {
  border-left-color: var(--color-warning);
}

.markdown-alert.markdown-alert-warning .markdown-alert-title {
  color: var(--color-warning);
}

.markdown-alert.markdown-alert-tip {
  border-left-color: var(--color-tip);
}

.markdown-alert.markdown-alert-tip .markdown-alert-title {
  color: var(--color-tip);
}

.markdown-alert.markdown-alert-caution {
  border-left-color: var(--color-caution);
}

.markdown-alert.markdown-alert-caution .markdown-alert-title {
  color: var(--color-caution);
}

</style>
        
        </head>
        <body class="vscode-body vscode-light">
            <h1 id="cc期末考试模拟题答案2024">C/C++期末考试模拟题答案（2024）</h1>
<p><strong><a href="https://gitee.com/xingyongkang/projects">xing yongkang</a></strong></p>
<h2 id="1-单选题">1 单选题</h2>
<h3 id="11-下列程序代码正确的输出结果是-">1.1 下列程序代码，正确的输出结果是（ ）</h3>
<p>int a=0xfe;
char b=062;
cout&lt;&lt;a&lt;&lt;&quot;,&quot;&lt;&lt;b&lt;&lt;endl;</p>
<p>A.0xfe,062
B.fe,62
C.254,2
D.254,62</p>
<p>解答：这个题目考点在于不同进制的转换和表示问题。0x表示16进制，0表示8进制，无表示10进制。所以a=15<em>16+14 =254，b=6</em>8+2 =50=0x32。因为数字0的ascaii码是0x30，所以0x32是2的sascii码。所以答案是C。</p>
<h3 id="12-下列代码能正确执行的是-">1.2 下列代码能正确执行的是（ ）</h3>
<p>A.
char a='C';
const char&amp; p=a;</p>
<p>B.
char a='C';
char* const p;
p=&amp;a;</p>
<p>C.
char a='C';
const char&amp; p;
p=a;</p>
<p>D.
char a='C';
char&amp; p;
p=a;</p>
<p>解答：这道题的考点在于指针变量和引用变量的定义与使用。引用变量是其它变量的别名，<strong>在定义时就必须初始化</strong>，据此选项c和d都错。对于选项b，按照我讲的变量定义的螺旋识别法，可以看出p是一个<strong>常指针</strong>，它的值不能被改变，所以该选项也错。选项a正确地定义了引用，所以正确。</p>
<h3 id="13-new和delete运算符正确的使用是-">1.3 new和delete运算符正确的使用是（ ）</h3>
<p>A.
int* p=new int[10];
delete p;</p>
<p>B.
int* p=new int(10);
delete []p;</p>
<p>C.
vector<int>* v=new vector<int>[10];
delete []v;</p>
<p>D.
int* a=new int[]{1,2,3,4};
delete []a;</p>
<p>解答：这道题目考点是动态分配的语法。动态分配有两种情况： 1是单变量分配和释放，语法：int * p = new int; delete p; 2是数组的分配和释放 int * p = new int[10]; delete []p;  分配后得到的都是指针。选项A错在释放数组的语法错误，该为delete [] p;  选项B错在把单变量当成了数组释放，该为delete p； 选项c正确，可能看起来有点怪，只要记住模版类只要给定模版参数，就是一个class，所以这里的vector<int> 就是一个class，和 int，float一样。 选项D错在动态分配的数组，不能这样初始化。</p>
<h3 id="14-下列哪个代码能够实现x和y值的交换-">1.4 下列哪个代码能够实现x和y值的交换（ ）</h3>
<p>A.
void fun(int a,int b) {
int x = a;
a = b;
b = x;
}
int main() {
int x = 1, y = 2;
fun(&amp;x, &amp;y);
cout &lt;&lt; x &lt;&lt; &quot;,&quot;&lt;&lt;y &lt;&lt; endl;
return 0;
}</p>
<p>B.
void fun(int* a,int* b) {
int x = *a;
*a = *b;
*b = x;
}
int main() {
int x = 1, y = 2;
fun(&amp;x,&amp;y);
cout &lt;&lt; x &lt;&lt; &quot;,&quot;&lt;&lt;y &lt;&lt; endl;
return 0;
}</p>
<p>C.
void fun(int&amp; a,int&amp; b) {
int x = a;
a = b;
b = x;
}
int main() {
int x = 1, y = 2;
fun(&amp;x, &amp;y);
cout &lt;&lt; x &lt;&lt; &quot;,&quot;&lt;&lt;y &lt;&lt; endl;
return 0;
}</p>
<p>D.
void fun(const int&amp;a,const int&amp;b) {
int x = a;
a = b;
b = x;
}
int main() {
int x = 1, y = 2;
fun(x, y);
cout &lt;&lt; x &lt;&lt; &quot;,&quot;&lt;&lt;y &lt;&lt; endl;
return 0;
}</p>
<p>解答： 这道题目的考点在于C/C++语言的函数没有副作用，即作为函数的参数是传入变量的拷贝，在函数内修改该值，不会改变变量的值。一句话，c语言在函数内不能改变外部变量的值。如果要改变，可以借助于指针，通过间接引用来达到目的；而到了c++时代，引入了引用类型，它可不是变量的拷贝，就是变量本尊，因此通过它就可以直接在函数内改变外部变量的值。选项A 调用函数时参数类型不匹配，错得离谱；选项B正确；选项c错在函数的参数是引用，调用是却传递了变量的地址，改为fun(x,y)就对了；选项d快对了，但错在函数申明它的参数是常引用，即不能改变该引用的值。</p>
<h3 id="15-下面有一个结构体对结构体的错误使用是-">1.5 下面有一个结构体，对结构体的错误使用是（ ）</h3>
<p>struct Book{
string name;
double price;
}</p>
<p>A.
Book b{&quot;C++&quot;,20};</p>
<p>B.
Book b;
b-&gt;name=&quot;C++&quot;;
b-&gt;price=20;</p>
<p>C.
Book *b=new Book[2];
b[0].name=&quot;C++&quot;;
b[0].price=20;</p>
<p>D.
Book *p=new Book();
p-&gt;name=&quot;C++&quot;;
p-&gt;price=20;</p>
<p>解答：考点是结构的定义和使用，包括静态和动态分配的语法。选项B错在对符号-&gt;的使用，-&gt;是（*b).的简化写法，前提是b必须是指向结构的指针，而这里的b不是指针；选项c正确，尽管是动态分配，但用了数组的下标访问语法；选项d正确，最标准的使用方法。选项a我曾近犹豫了一下，觉得缺了一个等号，但看到选项b，我就没选它，结构可以这样初始化，并不奇怪，毕竟编译器在竭力讨好programer，而且这个对她来说也不难。</p>
<h3 id="16-下列种类的函数中哪一种不是类的成员函数">1.6 下列种类的函数中，哪一种不是类的成员函数？</h3>
<p>A.
构造函数
B.
析构函数
C.
友元函数
D.
拷贝构造函数</p>
<p>解答：这道题目考点在于类的基本概念。类是数据和函数的封装体，这些函数按照具体的作用和特点，分为构造函数（其中有一个特殊的称为拷贝函数），析构函数，set函数，get函数，其它接口函数等。而友元函数不是类的成员函数，一般用于运算符重载（突破类的私有变量的访问性问题）。所以答案是选项c。</p>
<h3 id="17-当变量x的输入值是9时下面程序的运行结果是">1.7 当变量x的输入值是9时，下面程序的运行结果是：</h3>
<p>#include <iostream>
#include <string>
using namespace std;
int main()
{
int x;
cin&gt;&gt;x;
try
{
cout&lt;&lt;&quot;begin&quot;&lt;&lt;endl;
if(x&gt;100)
{
cout&lt;&lt;&quot;1&quot;&lt;&lt;endl;
throw string(&quot;too big.&quot;);
}
else
{
cout&lt;&lt;&quot;x=&quot;&lt;&lt;x&lt;&lt;endl;
}
cout&lt;&lt;&quot;2&quot;&lt;&lt;endl;
}
catch(string e)
{
cout&lt;&lt;&quot;3:&quot;&lt;&lt;e&lt;&lt;endl;
}
cout&lt;&lt;&quot;end&quot;&lt;&lt;endl;
return 0;
}</p>
<p>A.
begin
1
2
end</p>
<p>B.
begin
1
3: too big.
2
end</p>
<p>C.
begin
x=9
2
end</p>
<p>D.
begin
1
3: too big.
end</p>
<p>解答：考点是异常处理机制。与条件转移和循环一样，异常处理语句也是一种程序控制结构。如果没有触发throw语句，那么他的整个机制就不会发生作用，就和不存在一样。本题目中，不会执行throw语句，所以答案就是C。</p>
<h3 id="1-9-下列哪个代码不会调用对象的拷贝构造函数-">1-9 下列哪个代码不会调用对象的拷贝构造函数（ ）</h3>
<p>A.
MyClass a;
MyClass b=a;</p>
<p>B.
MyClass a;
MyClass b(a);</p>
<p>C.
MyClass a;
MyClass&amp; b=a;</p>
<p>D.
void f(MyClass obj)
{
....
}
MyClass a;
f(a);</p>
<p>解答： 考点是类的拷贝构造函数的用处。拷贝构造函数是一个特殊的构造函数，它用在以下三处： 1 用同类型变量初始化，就是选项A和选项B的情况； 2 作为函数的参数，就是选项D的情况；3 作为函数的返回值。选项C定义并初始化了一个引用变量，并不需要建立对象，所以不会使用拷贝构造函数。所以答案是C。多说两句，我在上课时没有着力强调拷贝构造函数，只要求大家理解如下两点： 1 模范类就是这个类用起来象int，float等一些基本类型一样。因此它必须支持前面说的三种情况，其实就是能完成变量的一个拷贝。而该功能呢就是通过调用拷贝构造函数完成的； 2 一般不需要自己写这个函数，编译器会帮你完成一个。只要类的数据成员没有指针类型，都能满足要求。如果你要进一步研究，可以查阅主题“深拷贝和浅拷贝”。</p>
<h3 id="110-根据下列类模板声明正确初始化对象的方式是-">1.10 根据下列类模板声明，正确初始化对象的方式是（ ）</h3>
<p>template&lt;typename T1, typename T2&gt;
class MyClass{
private:
T1 x;
T2 y;
public:
MyClass(T1 _x, T2 _y):x(_x),y(_y){}
};</p>
<p>A.
MyClass&lt;int,char&gt; a(10,'a');</p>
<p>B.
MyClass a(10,'a');</p>
<p>C.
MyClass&lt;int,char&gt; a;</p>
<p>D.
MyClass a;</p>
<p>解答： 考点是模版类的使用。模版类是含有参数的类模版，它不是类，只有指定了参数，它才能成为类。选项A正确；选项C和D吧模版类当成了类使用，错误；选项C定义正确，但没有进行初始化，不符合题目要求。</p>
<h2 id="2-函数题">2 函数题</h2>
<h3 id="21">2.1</h3>
<p>本题要求定义一个教师类Teacher，数据成员包含姓名name和年龄age，类的声明见给出的代码，请给出类的完整实现，并通过测试程序。</p>
<p>类的声明：</p>
<pre><code>class Teacher{
    private:
        string name;
        int age;
    public:
        Teacher(string name,int age);
        string getName() const;
        int getAge() const ;
        void setName(string name);
        void setAge(int age);
};
测试程序：
#include&lt;iostream&gt;
#include&lt;string&gt;
using namespace std;
class Teacher{
    private:
        string name;
        int age;
    public:
        Teacher(string name,int age);
        string getName() const;
        int getAge() const ;
        void setName(string name);
        void setAge(int age);
};

/* 请在这里填写答案 */

int main(){
    Teacher a(&quot;Wang&quot;,20);
    cout&lt;&lt;&quot;name:&quot;&lt;&lt;a.getName()&lt;&lt;endl;
    cout&lt;&lt;&quot;age:&quot;&lt;&lt;a.getAge()&lt;&lt;endl;
    a.setName(&quot;Zhang&quot;);
    a.setAge(30);
    cout&lt;&lt;&quot;name:&quot;&lt;&lt;a.getName()&lt;&lt;endl;
    cout&lt;&lt;&quot;age:&quot;&lt;&lt;a.getAge()&lt;&lt;endl;
    return 0;
}
测试程序的输入：

测试程序的输出：
name:Wang
age:20
name:Zhang
age:30
注意：“:”是英文冒号

提示
下列代码为类实现的骨架代码

Teacher::Teacher(string name,int age){
    //代码
}
string Teacher::getName() const{
    //代码
}
int Teacher::getAge() const{
    //代码
}
void Teacher::setName(string name)
{
    //代码
}
void Teacher::setAge(int age)
{
    //代码
}
</code></pre>
<p>解答：本题目考点是最基本的类的定义语法。代码见下面，说明几点：</p>
<ol>
<li>因为这是一道函数题，题目中已经给出了类的声明，我们对类的成员函数的实现只能写在类的定义的外边，这时候每个成员函数的名字前面必须要写上名字空间，即Teacher::(我们上课没有讲)。</li>
<li>题目给出了框架，只需要填空，所以比较简单。</li>
<li>关于this的使用。在成员函数的定义中，对成员变量可以直接使用，不需要前面加上运算符&quot;-&gt;&quot;。但当参数变量名与成员变量相同时，最好使用该运算符，以表示区别，但事实上编译器可以区分两者（最起码以前是这样）。</li>
</ol>
<pre><code>Teacher::Teacher(string pname, int age)
{
    name = pname;
    this-&gt;age = age;
}
string Teacher::getName() const
{
    return this-&gt;name;
}   
int Teacher::getAge() const
{
    return this-&gt;age;
}
void Teacher::setName(string name)
{
    this-&gt;name = name;
}
void Teacher::setAge(int age)
{
    this-&gt;age = age;
}
</code></pre>
<h2 id="22">2.2</h2>
<pre><code>本题要求定义一个二维向量类Vec2，类的声明见给出的代码，请给出类的完整实现，并通过测试程序。类的声明包括如下内容：

数据成员，向量的第一维u和第二维v；
u和v的访问函数；
构造函数；
加号、减号运算符重载（遵守二维向量的运算规则）；
==和!=运算符重载（遵守二维向量的运算规则）
输入、输出运算符重载。
类实现代码需要补充构造函数以及加、不等、输入输出运算。

类的声明：
class Vec2{
    private:
        double u;
        double v;
    public:
        Vec2(double u=0,double v=0);
        double getU() const;
        double getV() const;
        Vec2 operator+(const Vec2&amp;b);
        friend Vec2 operator-(const Vec2&amp;a,const Vec2&amp;b);
        bool operator==(const Vec2&amp;b) const;
        friend bool operator!=(const Vec2&amp;a,const Vec2&amp;b);
        friend ostream&amp;operator&lt;&lt;(ostream&amp;os,const Vec2&amp;c);
        friend istream&amp;operator&gt;&gt;(istream&amp;is,Vec2&amp;c);
};
测试程序：
#include&lt;iostream&gt;
using namespace std;
class Vec2{
    private:
        double u;
        double v;
    public:
        Vec2(double u=0,double v=0);
        double getU() const;
        double getV() const;
        Vec2 operator+(const Vec2&amp;b);
        friend Vec2 operator-(const Vec2&amp;a,const Vec2&amp;b);
        bool operator==(const Vec2&amp;b) const;
        friend bool operator!=(const Vec2&amp;a,const Vec2&amp;b);
        friend ostream&amp;operator&lt;&lt;(ostream&amp;os,const Vec2&amp;c);
        friend istream&amp;operator&gt;&gt;(istream&amp;is,Vec2&amp;c);
};
double Vec2::getU() const
{
    return u;
}
double Vec2::getV() const
{
    return v;
}
Vec2 operator-(const Vec2&amp;a,const Vec2&amp;b){
    return Vec2(a.u-b.u,a.v-b.v);
}
bool Vec2::operator==(const Vec2&amp;b) const{
    return u==b.u&amp;&amp;v==b.v;
}
/* 请在这里填写答案 */

int main(){
    Vec2 a;
    cin&gt;&gt;a;
    cout&lt;&lt;&quot;a: &quot;&lt;&lt;a&lt;&lt;endl;
    Vec2 b(3,4);
    Vec2 c=a+b;
    cout&lt;&lt;&quot;c: &quot;&lt;&lt;c&lt;&lt;endl;
    Vec2 d=a-b;
    cout&lt;&lt;&quot;d: &quot;&lt;&lt;d&lt;&lt;endl;
    cout&lt;&lt;&quot;a==a: &quot;&lt;&lt;(a==a)&lt;&lt;endl;
    cout&lt;&lt;&quot;a!=a: &quot;&lt;&lt;(a!=a)&lt;&lt;endl;
    return 0;
}
测试程序的输入：
10 5
测试程序的输出：
a: u=10,v=5
c: u=13,v=9
d: u=7,v=1
a==a: 1
a!=a: 0
注意：“:”和“,”为英文，“:”后有一个空格

提示
下列代码为类实现的骨架代码

Vec2::Vec2(double u,double v){
    //代码
}
Vec2 Vec2::operator+(const Vec2&amp;b){
    //代码
}
bool operator!=(const Vec2&amp;a,const Vec2&amp;b)
{
    //代码
}
ostream&amp;operator&lt;&lt;(ostream&amp;os,const Vec2&amp;c){
   //代码
}
istream&amp;operator&gt;&gt;(istream&amp;is,Vec2&amp;c){
   //代码
}
</code></pre>
<p>解答：本题目的考点是模范类的定义。即定义一个与int，float一样好用的类,所以要对运算符进行重载。说明如下：</p>
<ol>
<li>给出了框架，相对比较简单。</li>
<li>类的成员u和v是private，那么要注意对它们的访问有以下几种情况： 一是在该类的成员函数中可以直接使用，特别是当类的对象作为成员函数的参数时，在成员函数中仍然可以直接访问该类的所有成员（如下面的operator+，operator！=中，对引用a和b的成员的直接访问）；二是通过对象的接口访问，即public的get和set函数去访问；三是在申明的friend函数（或类）中可以直接访问（如下面的operator&lt;&lt;,operator&gt;&gt;).</li>
</ol>
<pre><code>Vec2::Vec2(double u,double v){
    this-&gt;u = u;
    this-&gt;v = v;
}
Vec2 Vec2::operator+(const Vec2&amp;b){
    Vec2 temp(u + b.u,v + b.v);
    return temp;
}
bool operator!=(const Vec2&amp;a,const Vec2&amp;b)
{
    return (a.u!= b.u|| a.v != b.v);
}
ostream&amp;operator&lt;&lt;(ostream&amp;os,const Vec2&amp;c){
   os&lt;&lt;&quot;u=&quot;&lt;&lt;c.u&lt;&lt;&quot;,v=&quot;&lt;&lt;c.v;
    return os;
}
istream&amp;operator&gt;&gt;(istream&amp;is,Vec2&amp;c){
   is&gt;&gt;c.u&gt;&gt;c.v;
   return is;
}
</code></pre>
<h3 id="23">2.3</h3>
<pre><code>请设计水果和香蕉类，并通过测试程序，具体要求如下：

水果（Fruit）是基类，成员包含：
保护成员变量重量（weight，int类型）
公有构造函数
公有析构函数
公有函数display
香蕉（Banana）从水果类公有继承，成员包含：
私有成员变量产地（origin，string类型）
公有构造函数
公有析构函数
公有函数display
对应代码

Fruit f(10);
f.display();
输出为：

Fruit Constructor
weight=10
Fruit Destructor
对应代码

Banana a(&quot;Chongqing&quot;,10);
a.display();
输出为：

Fruit Constructor
Banana Constructor
origin=Chongqing,weight=10
Banana Destructor
Fruit Destructor
对应代码

Fruit *pf=new Banana(&quot;Chongqing&quot;,10);;
pf-&gt;display();
delete pf;
输出为：

Fruit Constructor
Banana Constructor
origin=Chongqing,weight=10
Banana Destructor
Fruit Destructor
测试程序
#include&lt;iostream&gt;
#include&lt;string&gt;
using namespace std;

/* 请在这里填写答案 */
int main(){
    Fruit *pf=new Banana(&quot;Chongqing&quot;,10);;
    pf-&gt;display();
    delete pf;
    return 0;
}
测试程序的输入

测试程序的输出
Fruit Constructor
Banana Constructor
origin=Chongqing,weight=10
Banana Destructor
Fruit Destrucs
</code></pre>
<p>解答：考点是类的继承和多态技巧。题目不难，但很有代表性，大家可以把答案作为模版熟记下来，以后就是对它的扩充。但由于我们教学重点不同，特对几点说明如下：</p>
<ol>
<li>子类（subclass）和父类（又称为基类baseclass）。子类对象可以当父类看，即子类对象可以赋值给父类类型的变量；但反过来不行。</li>
<li>c++语言强调变量的类型，所以当一个变量的类型是父类类型时，它就只能访问父类的成员。</li>
<li>通过<strong>指向子类对象的类型为父类的指针</strong>和<strong>类虚函数</strong>可以打破2的限制，即父类类型的指针，也可以访问子类的成员函数。</li>
<li>一般实现多态时，析构函数也要定义为虚函数。目的是释放一个对象时，可以通过多态调用子类的析构函数。本题目中，如果不定义析构函数为virtual，则delete pf语句执行时，由于pf类型是父类fruit，所以只会调用fruit的析构函数，输出就会缺一句“Banana Destructor”；而如果定义了父类析构函数为虚函数，则根据多态性，delete pf就会调用子类的构造函数，就会输出这一句。而子类的析构函数会自动调用父类的构造函数，所以还会输出“Fruit Destrucs“。</li>
<li>当一个成员函数在基类中定义为虚函数，则在继承类中，该函数前面加不加virtual都一样。</li>
</ol>
<pre><code>class Fruit
{
    protected:
       int weight;
    public:
       Fruit(int weight)
       {
           this-&gt;weight = weight;
           cout&lt;&lt;&quot;Fruit Constructor&quot;&lt;&lt;endl;
       }
       virtual ~Fruit()
       {
           cout&lt;&lt;&quot;Fruit Destructor&quot;&lt;&lt;endl;
       }
       virtual void displzi lei
       {
           cout&lt;&lt;&quot;weight=&quot;&lt;&lt;weight&lt;&lt;endl;
       }
};

class Banana : public Fruit
{
    private:
        string origin;
    public:
        Banana(string origin, int weight) : Fruit(weight)
        {
           this-&gt;origin = origin; 
           cout&lt;&lt;&quot;Banana Constructor&quot;&lt;&lt;endl;
        }
        ~Banana()
        {
            cout&lt;&lt;&quot;Banana Destructor&quot;&lt;&lt;endl;
        }
        void display()
        {
            cout&lt;&lt;&quot;origin=&quot;&lt;&lt;origin&lt;&lt;&quot;,weight=&quot;&lt;&lt;weight&lt;&lt;endl;
        }
};

</code></pre>
<h2 id="3-编程题">3 编程题</h2>
<h3 id="31">3.1</h3>
<p>当整数a除以整数b(b≠0)，除得的商正好是整数而没有余数时，称b是a的约数。给你两个正整数A和B, 如果B是A的约数，请打印输出A+B, 否则打印输出A−B。</p>
<p>输入格式:
输入包括两个正整数A和B（1≤B≤A≤100）。</p>
<p>输出格式:
输出结果。</p>
<p>输入样例1:
12 4
输出样例1:
16
输入样例2:
20 8
输出样例2:
12
输入样例3:
1 1
输出样例3:
2</p>
<p>解答：</p>
<pre><code>#include &lt;iostream&gt;
using namespace std;
int main()
{
    int A,B;
    cin&gt;&gt;A&gt;&gt;B;
    if(A%B == 0)
    {
        cout&lt;&lt;A+B;
        
    }
    else
    {
        cout&lt;&lt; A-B;
    }
}
</code></pre>
<h2 id="32">3.2</h2>
<p>对于n位的两个正整数x和y，可以把x表示为<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mn>1</mn></msub><msub><mi>x</mi><mn>2</mn></msub><mo separator="true">,</mo><mo>…</mo><mo separator="true">,</mo><msub><mi>x</mi><mi>n</mi></msub></mrow><annotation encoding="application/x-tex">x_1 x_2,…, x_n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="minner">…</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.1514em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，其中<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">x_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>（1≤i≤n）表示整数x第i位上的数字；把y表示为<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>y</mi><mn>1</mn></msub><msub><mi>y</mi><mn>2</mn></msub><mo>…</mo><msub><mi>y</mi><mi>n</mi></msub></mrow><annotation encoding="application/x-tex">y_1 y_2…y_n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="minner">…</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.1514em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>，其中<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>y</mi><mi>i</mi></msub><mo stretchy="false">(</mo><mn>1</mn><mo>≤</mo><mi>i</mi><mo>≤</mo><mi>n</mi><mtext>）</mtext></mrow><annotation encoding="application/x-tex">y_i(1≤i≤n）</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord">1</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7955em;vertical-align:-0.136em;"></span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">n</span><span class="mord cjk_fallback">）</span></span></span></span>表示整数y第i位上的数字。如果<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mrow><mn>1</mn><mo>+</mo><mi>k</mi></mrow></msub><mo>=</mo><msub><mi>y</mi><mrow><mi>n</mi><mo>−</mo><mi>k</mi></mrow></msub></mrow><annotation encoding="application/x-tex">x_{1+k}=y_{n−k}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6389em;vertical-align:-0.2083em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3361em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span><span class="mbin mtight">+</span><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2083em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6389em;vertical-align:-0.2083em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3361em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span><span class="mbin mtight">−</span><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2083em;"><span></span></span></span></span></span></span></span></span></span>（0≤k≤n−1）始终成立，则x和y互为逆序整数。
给你两个正整数A和B, 判断两个整数是否互为逆序整数，并输出相应的结果。
注：题目保证正整数A和B的个位数字不是0。</p>
<p>输入格式:
先在第一行输入位数n，然后在接下来的两行分别输入位数为n的正整数A和B（1≤n≤50）。</p>
<p>输出格式:
输入样例1:
2
89
98
输出样例1:
89 and 98 are reverse.
输入样例2:
3
981
289
输出样例2:
981 and 289 are not reverse.
提示：</p>
<p>输入的两个正整数可能会超过long long int所能表示数的范围。可以用字符串来表示正整数。</p>
<p>输出结果以“.”结尾。</p>
<p>解答：</p>
<ol>
<li>按照提示，由于整数较长，所以直接采用string类型表示这两个整数。</li>
<li>判断字符串的逆，也可以用模版函数reverse。</li>
</ol>
<pre><code>#include &lt;iostream&gt;
using namespace std;
int main()
{
    int n;
    cin&gt;&gt;n;
    string A,B;
    cin&gt;&gt;A&gt;&gt;B;
    bool bIfReverse = true;
    for(int i = 0; i&lt;A.size(); i++)
    {
        if(A[i] != B[B.size()-1-i])
        {
            bIfReverse = false;
            break;
        }
    }
    if(bIfReverse)
        cout&lt;&lt; A &lt;&lt;&quot; and &quot;&lt;&lt;B &lt;&lt;&quot; are reverse.&quot;;
    else
        cout&lt;&lt;A&lt;&lt;&quot; and &quot;&lt;&lt;B &lt;&lt; &quot; are not reverse.&quot;;
}

</code></pre>
<p>以下是使用reverse的代码，其中C是A的reverse</p>
<pre><code>#include &lt;iostream&gt;
#include &lt;algorithm&gt;
using namespace std;
int main()
{
    int n;
    cin&gt;&gt;n;
    string A,B;
    cin&gt;&gt;A&gt;&gt;B;
    string C = A;
    reverse(C.begin(),C.end());
    if(B==C)
       cout&lt;&lt; A &lt;&lt;&quot; and &quot;&lt;&lt;B &lt;&lt;&quot; are reverse.&quot;;
    else
        cout&lt;&lt;A&lt;&lt;&quot; and &quot;&lt;&lt;B &lt;&lt; &quot; are not reverse.&quot;;
}

</code></pre>
<h3 id="33">3.3</h3>
<p>可怕的阿尔法病毒正在一维世界传播，如果某人的活动范围与病毒携带者的活动范围有交集，则有被感染的可能。假设有一名病毒携带者A在位于X的家附近活动，他到过的地方用<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">x_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>表示（这些地点不重复），对于X和<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">x_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>之间的区域，都认为是A的活动范围。另外有一名健康者B，他在位于Y的家附近活动，他到过的地方用<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>y</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">y_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>表示（这些地点不重复），对于Y和<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>y</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">y_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>之间的区域，都认为是B的活动范围。所有的地点都位于整数点上，$−100≤X,Y,x_i,y_i≤100。现在需要判断B是否有被感染的可能。</p>
<p>输入格式:
第一行输入N,M,X,Y四个整数，接下来2行分别是N个<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">x_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>和M个<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>y</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">y_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>的值。整数值之间都用空格隔开。具体如下：
N M X Y
<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">x_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>
<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">x_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>
​
...
<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mi>N</mi></msub></mrow><annotation encoding="application/x-tex">x_N</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.10903em;">N</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>
​<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>y</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">y_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>
​<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>y</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">y_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>
​...
<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>y</mi><mi>M</mi></msub></mrow><annotation encoding="application/x-tex">y_M</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.10903em;">M</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></p>
<p>输出格式:
用家的位置表示A和B两人，输出是否有被感染的可能，具体格式请参见样例。</p>
<p>输入样例1:
3 2 10 20
8 15 13
16 22
输出样例1:
10 and 20: impossible
输入样例2:
4 2 -48 -1
-20 -35 -91 -23
-22 66
输出样例2:
-48 and -1: possible
输入样例3:
5 3 6 8
-10 3 1 5 -100
100 6 14
输出样例3:
6 and 8: possible</p>
<p>解答：</p>
<ol>
<li>所有的活动点以及家都是整数，且位于闭区点[-100，100]。</li>
<li>思路如下：为X和Y分别建立一个整数数组（用vector<int>），存放各自所有的活动点以及家的位置；然后比较两个数组有没有共同元素，有，则有感染可能，否则没有感染可能。</li>
<li>思路较笨，但逻辑简单。下面的代码就是按照这个思路写的。</li>
</ol>
<pre><code>#include &lt;iostream&gt;
#include &lt;vector&gt;
using namespace std;
int main()
{
    int N,M,X,Y;
    cin&gt;&gt;N&gt;&gt;M&gt;&gt;X&gt;&gt;Y;
    vector&lt;int&gt; x,y;
    //录入X的活动点
    for(int i = 0; i&lt;N; i++)
    {
        int temp;
        cin&gt;&gt;temp;
        //根据家的位置与当前活动点temp的关系，分为两种情况
        if(X&gt;temp)
        {
            for(int j = temp; j&lt;X; j++)
                x.push_back(j);
        }
        else
        {
            for(int j = X; j&lt;=temp; j++)
                x.push_back(j);
        }
    }
    //录入Y的活动点
    for(int i = 0; i&lt;M;i++)
    {
        int temp;
        cin&gt;&gt;temp;
        //根据家的位置与当前活动点temp的关系，分为两种情况
        if(Y&gt;temp)
        {
            for(int j = temp; j&lt;Y; j++)
                y.push_back(j);
        }
        else
        {
            for(int j = Y; j&lt;=temp; j++)
                y.push_back(j);
        }
    }

    //检测两个数组有没有共同元素，输出结果
    bool bIfCross = false;
    for(int i = 0; i&lt;x.size(); i++)
    {
        for(int j = 0; j&lt;y.size(); j++)
        {
            if(x[i] == y[j])
            {
                bIfCross = true;
                break;
             }
        }
    }
    if(bIfCross)
        cout&lt;&lt;X &lt;&lt;&quot; and &quot;&lt;&lt; Y&lt;&lt;&quot;: possible&quot;;
    else
        cout&lt;&lt;X &lt;&lt; &quot; and &quot;&lt;&lt; Y &lt;&lt; &quot;: impossible&quot;;
}
</code></pre>
<p>也可以通过研究区间之间的逻辑关系来写程序。程序简单，但逻辑较复杂，容易遗漏。</p>
<ol>
<li>获取两个人的活动区间（只要找到每个区间的最大值和最小值）</li>
<li>判断两个区间有没有交集。</li>
</ol>
<pre><code>#include &lt;iostream&gt;
using namespace std;
int main()
{
    int N,M,X,Y;
    cin&gt;&gt;N&gt;&gt;M&gt;&gt;X&gt;&gt;Y;
    int nMin=X,nMax=X,mMin=Y,mMax=Y;
    //获得第一个人的活动区间。只要找到最大值nMin和最小值nMax就行，注意初始值设为了家X。
    for(int i = 0; i&lt;N; i++)
    {
        int temp;
        cin&gt;&gt;temp;
        if(temp&lt;nMin)
            nMin = temp;
        if(temp&gt;nMax)
            nMax = temp;
    }
    //获得第二个人的活动区间。只要找到最大值mMin和最小值mMax就行，注意初始值设为了家Y。
    for(int i = 0; i&lt;M;i++)
    {
        int temp;
        cin&gt;&gt;temp;
        if(temp&lt;mMin)
            mMin = temp;
        if(temp&gt;mMax)
            mMax = temp;
    }
    //判断两个区间[nMin, nMax]和[mMin,mMax]是否有交叉点。有交叉点的情况有些多，比较难写判定条件，但我们可以反过来想，判断没有交叉点是不是要容易些？因为只要两个区间在直线上相互分开就行，即一个的右边界比另一个左边界还小就行。因此可以写出下面的判别条件：
    if(!(nMax&lt;mMin || mMax &lt; nMin))
        cout&lt;&lt;X &lt;&lt;&quot; and &quot;&lt;&lt; Y&lt;&lt;&quot;: possible&quot;;
    else
        cout&lt;&lt;X &lt;&lt; &quot; and &quot;&lt;&lt; Y &lt;&lt; &quot;: impossible&quot;;
}
</code></pre>
<h2 id="logs">Logs:</h2>
<ul>
<li>20221120：version1</li>
<li>20221128: 改正了2-2的错误</li>
<li></li>
</ul>

            <script async src="https://cdn.jsdelivr.net/npm/katex-copytex@latest/dist/katex-copytex.min.js"></script>
            
        </body>
        </html>